/**
 * 动态字典加载器
 * 支持动态加载和注册模块字典类型
 * 提供模块字典类型的加载、卸载、重新加载和批量加载功能
 */
import { type ModuleInfo } from './types';
import { MODULE_DICT_REGISTRY, registerModuleDictTypes } from './registry';

// 已加载的模块缓存
const loadedModules = new Map<string, boolean>();

/**
 * 动态加载模块字典类型
 * @param moduleName 模块名称
 * @param moduleInfo 模块信息，包含名称、描述和字典类型列表
 * @returns 是否加载成功
 * @example
 * ```typescript
 * const bomModuleInfo = {
 *   name: 'bom',
 *   description: 'BOM模块',
 *   dictTypes: [DICT_TYPE.BOM_TYPE, DICT_TYPE.BOM_STATUS]
 * };
 * const success = await loadModuleDictTypes('bom', bomModuleInfo);
 * console.log(success); // true
 * ```
 */
export async function loadModuleDictTypes(moduleName: string, moduleInfo: ModuleInfo): Promise<boolean> {
  try {
    // 检查模块是否已加载
    if (loadedModules.has(moduleName)) {
      console.log(`模块 ${moduleName} 已加载`);
      return true;
    }

    // 注册模块字典类型
    registerModuleDictTypes(moduleName, moduleInfo.dictTypes);
    
    // 标记模块为已加载
    loadedModules.set(moduleName, true);
    
    console.log(`模块 ${moduleName} 字典类型加载成功`);
    return true;
  } catch (error) {
    console.error(`加载模块 ${moduleName} 字典类型失败:`, error);
    return false;
  }
}

/**
 * 动态卸载模块字典类型
 * @param moduleName 模块名称
 * @returns 是否卸载成功
 * @example
 * ```typescript
 * const success = unloadModuleDictTypes('bom');
 * console.log(success); // true
 * ```
 */
export function unloadModuleDictTypes(moduleName: string): boolean {
  try {
    // 检查模块是否已加载
    if (!loadedModules.has(moduleName)) {
      console.log(`模块 ${moduleName} 未加载`);
      return false;
    }

    // 从注册表中移除模块
    delete MODULE_DICT_REGISTRY[moduleName];
    
    // 标记模块为未加载
    loadedModules.delete(moduleName);
    
    console.log(`模块 ${moduleName} 字典类型卸载成功`);
    return true;
  } catch (error) {
    console.error(`卸载模块 ${moduleName} 字典类型失败:`, error);
    return false;
  }
}

/**
 * 检查模块是否已加载
 * @param moduleName 模块名称
 * @returns 是否已加载
 * @example
 * ```typescript
 * const isLoaded = isModuleLoaded('bom');
 * console.log(isLoaded); // true 或 false
 * ```
 */
export function isModuleLoaded(moduleName: string): boolean {
  return loadedModules.has(moduleName) || false;
}

/**
 * 获取所有已加载的模块名称列表
 * @returns 已加载的模块名称数组
 * @example
 * ```typescript
 * const loadedModules = getLoadedModules();
 * console.log(loadedModules); // ['bom', 'system', ...]
 * ```
 */
export function getLoadedModules(): string[] {
  return Array.from(loadedModules.keys());
}

/**
 * 重新加载模块字典类型
 * 先卸载模块，再重新加载
 * @param moduleName 模块名称
 * @param moduleInfo 模块信息，包含名称、描述和字典类型列表
 * @returns 是否重新加载成功
 * @example
 * ```typescript
 * const bomModuleInfo = {
 *   name: 'bom',
 *   description: 'BOM模块',
 *   dictTypes: [DICT_TYPE.BOM_TYPE, DICT_TYPE.BOM_STATUS]
 * };
 * const success = await reloadModuleDictTypes('bom', bomModuleInfo);
 * console.log(success); // true
 * ```
 */
export async function reloadModuleDictTypes(moduleName: string, moduleInfo: ModuleInfo): Promise<boolean> {
  // 先卸载
  unloadModuleDictTypes(moduleName);
  // 再加载
  return await loadModuleDictTypes(moduleName, moduleInfo);
}

/**
 * 批量加载模块字典类型
 * @param modules 模块信息映射，键为模块名称，值为模块信息
 * @returns 加载结果映射，键为模块名称，值为是否加载成功
 * @example
 * ```typescript
 * const modules = {
 *   'bom': {
 *     name: 'bom',
 *     dictTypes: [DICT_TYPE.BOM_TYPE, DICT_TYPE.BOM_STATUS]
 *   },
 *   'product': {
 *     name: 'product',
 *     dictTypes: [DICT_TYPE.PRODUCT_TYPE, DICT_TYPE.PRODUCT_STATUS]
 *   }
 * };
 * const results = await batchLoadModuleDictTypes(modules);
 * console.log(results); // { bom: true, product: true }
 * ```
 */
export async function batchLoadModuleDictTypes(modules: Record<string, ModuleInfo>): Promise<Record<string, boolean>> {
  const results: Record<string, boolean> = {};
  
  for (const [moduleName, moduleInfo] of Object.entries(modules)) {
    results[moduleName] = await loadModuleDictTypes(moduleName, moduleInfo);
  }
  
  return results;
}

/**
 * 获取模块加载状态信息
 * @returns 模块加载状态信息，键为模块名称，值为加载状态和字典类型数量
 * @example
 * ```typescript
 * const status = getModuleLoadStatus();
 * console.log(status);
 * // {
 * //   bom: { loaded: true, dictTypesCount: 10 },
 * //   system: { loaded: true, dictTypesCount: 15 },
 * //   product: { loaded: false, dictTypesCount: 0 }
 * // }
 * ```
 */
export function getModuleLoadStatus(): Record<string, { loaded: boolean; dictTypesCount: number }> {
  const status: Record<string, { loaded: boolean; dictTypesCount: number }> = {};
  
  // 获取所有已注册的模块
  const registeredModules = Object.keys(MODULE_DICT_REGISTRY);
  
  // 合并已加载模块和已注册模块
  const allModules = new Set([...registeredModules, ...getLoadedModules()]);
  
  for (const moduleName of allModules) {
    const dictTypes = MODULE_DICT_REGISTRY[moduleName] || [];
    status[moduleName] = {
      loaded: isModuleLoaded(moduleName),
      dictTypesCount: dictTypes.length
    };
  }
  
  return status;
}